// $ANTLR 3.3 Nov 30, 2010 12:45:30 C:\\projects\\Expressions\\antlr\\Expression.g 2011-04-28 19:47:48

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 219
// Unreachable code detected.
#pragma warning disable 162


using Antlr.Runtime;

namespace SimpleSpreadsheet.Core.Parser
{
    [System.CodeDom.Compiler.GeneratedCode("ANTLR", "3.3 Nov 30, 2010 12:45:30")]
    [System.CLSCompliant(false)]
    public partial class ExpressionLexer : Antlr.Runtime.Lexer
    {
        public const int EOF = -1;
        public const int T__34 = 34;
        public const int T__35 = 35;
        public const int T__36 = 36;
        public const int PARAM = 4;
        public const int REFERENCE = 5;
        public const int RANGEREFERENCE = 6;
        public const int NEGATE = 7;
        public const int STRING = 8;
        public const int OR = 9;
        public const int AND = 10;
        public const int EQUALS = 11;
        public const int NOTEQUALS = 12;
        public const int LT = 13;
        public const int LTEQ = 14;
        public const int GT = 15;
        public const int GTEQ = 16;
        public const int PLUS = 17;
        public const int MINUS = 18;
        public const int MULT = 19;
        public const int DIV = 20;
        public const int MOD = 21;
        public const int POW = 22;
        public const int NOT = 23;
        public const int INTEGER = 24;
        public const int FLOAT = 25;
        public const int REF = 26;
        public const int REFRANGE = 27;
        public const int PAR = 28;
        public const int EscapeSequence = 29;
        public const int FUNCTION = 30;
        public const int UnicodeEscape = 31;
        public const int HexDigit = 32;
        public const int WS = 33;

        // delegates
        // delegators

        public ExpressionLexer()
        {
            OnCreated();
        }

        public ExpressionLexer(ICharStream input)
            : this(input, new RecognizerSharedState())
        {
        }

        public ExpressionLexer(ICharStream input, RecognizerSharedState state)
            : base(input, state)
        {


            OnCreated();
        }
        public override string GrammarFileName { get { return "C:\\projects\\Expressions\\antlr\\Expression.g"; } }

        private static readonly bool[] decisionCanBacktrack = new bool[0];


        partial void OnCreated();
        partial void EnterRule(string ruleName, int ruleIndex);
        partial void LeaveRule(string ruleName, int ruleIndex);

        partial void Enter_T__34();
        partial void Leave_T__34();

        // $ANTLR start "T__34"
        [GrammarRule("T__34")]
        private void mT__34()
        {
            Enter_T__34();
            EnterRule("T__34", 1);
            TraceIn("T__34", 1);
            try
            {
                int _type = T__34;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:7:7: ( '(' )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:7:9: '('
                {
                    DebugLocation(7, 9);
                    Match('(');

                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("T__34", 1);
                LeaveRule("T__34", 1);
                Leave_T__34();
            }
        }
        // $ANTLR end "T__34"

        partial void Enter_T__35();
        partial void Leave_T__35();

        // $ANTLR start "T__35"
        [GrammarRule("T__35")]
        private void mT__35()
        {
            Enter_T__35();
            EnterRule("T__35", 2);
            TraceIn("T__35", 2);
            try
            {
                int _type = T__35;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:8:7: ( ')' )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:8:9: ')'
                {
                    DebugLocation(8, 9);
                    Match(')');

                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("T__35", 2);
                LeaveRule("T__35", 2);
                Leave_T__35();
            }
        }
        // $ANTLR end "T__35"

        partial void Enter_T__36();
        partial void Leave_T__36();

        // $ANTLR start "T__36"
        [GrammarRule("T__36")]
        private void mT__36()
        {
            Enter_T__36();
            EnterRule("T__36", 3);
            TraceIn("T__36", 3);
            try
            {
                int _type = T__36;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:9:7: ( ',' )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:9:9: ','
                {
                    DebugLocation(9, 9);
                    Match(',');

                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("T__36", 3);
                LeaveRule("T__36", 3);
                Leave_T__36();
            }
        }
        // $ANTLR end "T__36"

        partial void Enter_OR();
        partial void Leave_OR();

        // $ANTLR start "OR"
        [GrammarRule("OR")]
        private void mOR()
        {
            Enter_OR();
            EnterRule("OR", 4);
            TraceIn("OR", 4);
            try
            {
                int _type = OR;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:56:5: ( '||' | 'or' )
                int alt1 = 2;
                try
                {
                    DebugEnterDecision(1, decisionCanBacktrack[1]);
                    int LA1_0 = input.LA(1);

                    if ((LA1_0 == '|'))
                    {
                        alt1 = 1;
                    }
                    else if ((LA1_0 == 'o'))
                    {
                        alt1 = 2;
                    }
                    else
                    {
                        NoViableAltException nvae = new NoViableAltException("", 1, 0, input);

                        DebugRecognitionException(nvae);
                        throw nvae;
                    }
                }
                finally { DebugExitDecision(1); }
                switch (alt1)
                {
                    case 1:
                        DebugEnterAlt(1);
                        // C:\\projects\\Expressions\\antlr\\Expression.g:56:8: '||'
                        {
                            DebugLocation(56, 8);
                            Match("||");


                        }
                        break;
                    case 2:
                        DebugEnterAlt(2);
                        // C:\\projects\\Expressions\\antlr\\Expression.g:56:15: 'or'
                        {
                            DebugLocation(56, 15);
                            Match("or");


                        }
                        break;

                }
                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("OR", 4);
                LeaveRule("OR", 4);
                Leave_OR();
            }
        }
        // $ANTLR end "OR"

        partial void Enter_AND();
        partial void Leave_AND();

        // $ANTLR start "AND"
        [GrammarRule("AND")]
        private void mAND()
        {
            Enter_AND();
            EnterRule("AND", 5);
            TraceIn("AND", 5);
            try
            {
                int _type = AND;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:62:6: ( '&&' | 'and' )
                int alt2 = 2;
                try
                {
                    DebugEnterDecision(2, decisionCanBacktrack[2]);
                    int LA2_0 = input.LA(1);

                    if ((LA2_0 == '&'))
                    {
                        alt2 = 1;
                    }
                    else if ((LA2_0 == 'a'))
                    {
                        alt2 = 2;
                    }
                    else
                    {
                        NoViableAltException nvae = new NoViableAltException("", 2, 0, input);

                        DebugRecognitionException(nvae);
                        throw nvae;
                    }
                }
                finally { DebugExitDecision(2); }
                switch (alt2)
                {
                    case 1:
                        DebugEnterAlt(1);
                        // C:\\projects\\Expressions\\antlr\\Expression.g:62:9: '&&'
                        {
                            DebugLocation(62, 9);
                            Match("&&");


                        }
                        break;
                    case 2:
                        DebugEnterAlt(2);
                        // C:\\projects\\Expressions\\antlr\\Expression.g:62:16: 'and'
                        {
                            DebugLocation(62, 16);
                            Match("and");


                        }
                        break;

                }
                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("AND", 5);
                LeaveRule("AND", 5);
                Leave_AND();
            }
        }
        // $ANTLR end "AND"

        partial void Enter_EQUALS();
        partial void Leave_EQUALS();

        // $ANTLR start "EQUALS"
        [GrammarRule("EQUALS")]
        private void mEQUALS()
        {
            Enter_EQUALS();
            EnterRule("EQUALS", 6);
            TraceIn("EQUALS", 6);
            try
            {
                int _type = EQUALS;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:69:2: ( '=' | '==' )
                int alt3 = 2;
                try
                {
                    DebugEnterDecision(3, decisionCanBacktrack[3]);
                    int LA3_0 = input.LA(1);

                    if ((LA3_0 == '='))
                    {
                        int LA3_1 = input.LA(2);

                        if ((LA3_1 == '='))
                        {
                            alt3 = 2;
                        }
                        else
                        {
                            alt3 = 1;
                        }
                    }
                    else
                    {
                        NoViableAltException nvae = new NoViableAltException("", 3, 0, input);

                        DebugRecognitionException(nvae);
                        throw nvae;
                    }
                }
                finally { DebugExitDecision(3); }
                switch (alt3)
                {
                    case 1:
                        DebugEnterAlt(1);
                        // C:\\projects\\Expressions\\antlr\\Expression.g:69:4: '='
                        {
                            DebugLocation(69, 4);
                            Match('=');

                        }
                        break;
                    case 2:
                        DebugEnterAlt(2);
                        // C:\\projects\\Expressions\\antlr\\Expression.g:69:10: '=='
                        {
                            DebugLocation(69, 10);
                            Match("==");


                        }
                        break;

                }
                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("EQUALS", 6);
                LeaveRule("EQUALS", 6);
                Leave_EQUALS();
            }
        }
        // $ANTLR end "EQUALS"

        partial void Enter_NOTEQUALS();
        partial void Leave_NOTEQUALS();

        // $ANTLR start "NOTEQUALS"
        [GrammarRule("NOTEQUALS")]
        private void mNOTEQUALS()
        {
            Enter_NOTEQUALS();
            EnterRule("NOTEQUALS", 7);
            TraceIn("NOTEQUALS", 7);
            try
            {
                int _type = NOTEQUALS;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:71:2: ( '!=' | '<>' )
                int alt4 = 2;
                try
                {
                    DebugEnterDecision(4, decisionCanBacktrack[4]);
                    int LA4_0 = input.LA(1);

                    if ((LA4_0 == '!'))
                    {
                        alt4 = 1;
                    }
                    else if ((LA4_0 == '<'))
                    {
                        alt4 = 2;
                    }
                    else
                    {
                        NoViableAltException nvae = new NoViableAltException("", 4, 0, input);

                        DebugRecognitionException(nvae);
                        throw nvae;
                    }
                }
                finally { DebugExitDecision(4); }
                switch (alt4)
                {
                    case 1:
                        DebugEnterAlt(1);
                        // C:\\projects\\Expressions\\antlr\\Expression.g:71:4: '!='
                        {
                            DebugLocation(71, 4);
                            Match("!=");


                        }
                        break;
                    case 2:
                        DebugEnterAlt(2);
                        // C:\\projects\\Expressions\\antlr\\Expression.g:71:11: '<>'
                        {
                            DebugLocation(71, 11);
                            Match("<>");


                        }
                        break;

                }
                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("NOTEQUALS", 7);
                LeaveRule("NOTEQUALS", 7);
                Leave_NOTEQUALS();
            }
        }
        // $ANTLR end "NOTEQUALS"

        partial void Enter_LT();
        partial void Leave_LT();

        // $ANTLR start "LT"
        [GrammarRule("LT")]
        private void mLT()
        {
            Enter_LT();
            EnterRule("LT", 8);
            TraceIn("LT", 8);
            try
            {
                int _type = LT;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:77:4: ( '<' )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:77:6: '<'
                {
                    DebugLocation(77, 6);
                    Match('<');

                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("LT", 8);
                LeaveRule("LT", 8);
                Leave_LT();
            }
        }
        // $ANTLR end "LT"

        partial void Enter_LTEQ();
        partial void Leave_LTEQ();

        // $ANTLR start "LTEQ"
        [GrammarRule("LTEQ")]
        private void mLTEQ()
        {
            Enter_LTEQ();
            EnterRule("LTEQ", 9);
            TraceIn("LTEQ", 9);
            try
            {
                int _type = LTEQ;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:78:6: ( '<=' )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:78:8: '<='
                {
                    DebugLocation(78, 8);
                    Match("<=");


                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("LTEQ", 9);
                LeaveRule("LTEQ", 9);
                Leave_LTEQ();
            }
        }
        // $ANTLR end "LTEQ"

        partial void Enter_GT();
        partial void Leave_GT();

        // $ANTLR start "GT"
        [GrammarRule("GT")]
        private void mGT()
        {
            Enter_GT();
            EnterRule("GT", 10);
            TraceIn("GT", 10);
            try
            {
                int _type = GT;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:79:4: ( '>' )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:79:6: '>'
                {
                    DebugLocation(79, 6);
                    Match('>');

                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("GT", 10);
                LeaveRule("GT", 10);
                Leave_GT();
            }
        }
        // $ANTLR end "GT"

        partial void Enter_GTEQ();
        partial void Leave_GTEQ();

        // $ANTLR start "GTEQ"
        [GrammarRule("GTEQ")]
        private void mGTEQ()
        {
            Enter_GTEQ();
            EnterRule("GTEQ", 11);
            TraceIn("GTEQ", 11);
            try
            {
                int _type = GTEQ;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:80:6: ( '>=' )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:80:8: '>='
                {
                    DebugLocation(80, 8);
                    Match(">=");


                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("GTEQ", 11);
                LeaveRule("GTEQ", 11);
                Leave_GTEQ();
            }
        }
        // $ANTLR end "GTEQ"

        partial void Enter_PLUS();
        partial void Leave_PLUS();

        // $ANTLR start "PLUS"
        [GrammarRule("PLUS")]
        private void mPLUS()
        {
            Enter_PLUS();
            EnterRule("PLUS", 12);
            TraceIn("PLUS", 12);
            try
            {
                int _type = PLUS;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:86:6: ( '+' )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:86:8: '+'
                {
                    DebugLocation(86, 8);
                    Match('+');

                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("PLUS", 12);
                LeaveRule("PLUS", 12);
                Leave_PLUS();
            }
        }
        // $ANTLR end "PLUS"

        partial void Enter_MINUS();
        partial void Leave_MINUS();

        // $ANTLR start "MINUS"
        [GrammarRule("MINUS")]
        private void mMINUS()
        {
            Enter_MINUS();
            EnterRule("MINUS", 13);
            TraceIn("MINUS", 13);
            try
            {
                int _type = MINUS;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:87:7: ( '-' )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:87:9: '-'
                {
                    DebugLocation(87, 9);
                    Match('-');

                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("MINUS", 13);
                LeaveRule("MINUS", 13);
                Leave_MINUS();
            }
        }
        // $ANTLR end "MINUS"

        partial void Enter_MULT();
        partial void Leave_MULT();

        // $ANTLR start "MULT"
        [GrammarRule("MULT")]
        private void mMULT()
        {
            Enter_MULT();
            EnterRule("MULT", 14);
            TraceIn("MULT", 14);
            try
            {
                int _type = MULT;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:93:6: ( '*' )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:93:8: '*'
                {
                    DebugLocation(93, 8);
                    Match('*');

                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("MULT", 14);
                LeaveRule("MULT", 14);
                Leave_MULT();
            }
        }
        // $ANTLR end "MULT"

        partial void Enter_DIV();
        partial void Leave_DIV();

        // $ANTLR start "DIV"
        [GrammarRule("DIV")]
        private void mDIV()
        {
            Enter_DIV();
            EnterRule("DIV", 15);
            TraceIn("DIV", 15);
            try
            {
                int _type = DIV;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:94:5: ( '/' )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:94:7: '/'
                {
                    DebugLocation(94, 7);
                    Match('/');

                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("DIV", 15);
                LeaveRule("DIV", 15);
                Leave_DIV();
            }
        }
        // $ANTLR end "DIV"

        partial void Enter_MOD();
        partial void Leave_MOD();

        // $ANTLR start "MOD"
        [GrammarRule("MOD")]
        private void mMOD()
        {
            Enter_MOD();
            EnterRule("MOD", 16);
            TraceIn("MOD", 16);
            try
            {
                int _type = MOD;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:95:5: ( '%' )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:95:7: '%'
                {
                    DebugLocation(95, 7);
                    Match('%');

                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("MOD", 16);
                LeaveRule("MOD", 16);
                Leave_MOD();
            }
        }
        // $ANTLR end "MOD"

        partial void Enter_POW();
        partial void Leave_POW();

        // $ANTLR start "POW"
        [GrammarRule("POW")]
        private void mPOW()
        {
            Enter_POW();
            EnterRule("POW", 17);
            TraceIn("POW", 17);
            try
            {
                int _type = POW;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:101:5: ( '^' )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:101:7: '^'
                {
                    DebugLocation(101, 7);
                    Match('^');

                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("POW", 17);
                LeaveRule("POW", 17);
                Leave_POW();
            }
        }
        // $ANTLR end "POW"

        partial void Enter_NOT();
        partial void Leave_NOT();

        // $ANTLR start "NOT"
        [GrammarRule("NOT")]
        private void mNOT()
        {
            Enter_NOT();
            EnterRule("NOT", 18);
            TraceIn("NOT", 18);
            try
            {
                int _type = NOT;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:109:5: ( '!' | 'not' )
                int alt5 = 2;
                try
                {
                    DebugEnterDecision(5, decisionCanBacktrack[5]);
                    int LA5_0 = input.LA(1);

                    if ((LA5_0 == '!'))
                    {
                        alt5 = 1;
                    }
                    else if ((LA5_0 == 'n'))
                    {
                        alt5 = 2;
                    }
                    else
                    {
                        NoViableAltException nvae = new NoViableAltException("", 5, 0, input);

                        DebugRecognitionException(nvae);
                        throw nvae;
                    }
                }
                finally { DebugExitDecision(5); }
                switch (alt5)
                {
                    case 1:
                        DebugEnterAlt(1);
                        // C:\\projects\\Expressions\\antlr\\Expression.g:109:7: '!'
                        {
                            DebugLocation(109, 7);
                            Match('!');

                        }
                        break;
                    case 2:
                        DebugEnterAlt(2);
                        // C:\\projects\\Expressions\\antlr\\Expression.g:109:13: 'not'
                        {
                            DebugLocation(109, 13);
                            Match("not");


                        }
                        break;

                }
                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("NOT", 18);
                LeaveRule("NOT", 18);
                Leave_NOT();
            }
        }
        // $ANTLR end "NOT"

        partial void Enter_PAR();
        partial void Leave_PAR();

        // $ANTLR start "PAR"
        [GrammarRule("PAR")]
        private void mPAR()
        {
            Enter_PAR();
            EnterRule("PAR", 19);
            TraceIn("PAR", 19);
            try
            {
                int _type = PAR;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:138:5: ( ( 'X' | 'Y' ) )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:138:7: ( 'X' | 'Y' )
                {
                    DebugLocation(138, 7);
                    if ((input.LA(1) >= 'X' && input.LA(1) <= 'Y'))
                    {
                        input.Consume();

                    }
                    else
                    {
                        MismatchedSetException mse = new MismatchedSetException(null, input);
                        DebugRecognitionException(mse);
                        Recover(mse);
                        throw mse;
                    }


                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("PAR", 19);
                LeaveRule("PAR", 19);
                Leave_PAR();
            }
        }
        // $ANTLR end "PAR"

        partial void Enter_REF();
        partial void Leave_REF();

        // $ANTLR start "REF"
        [GrammarRule("REF")]
        private void mREF()
        {
            Enter_REF();
            EnterRule("REF", 20);
            TraceIn("REF", 20);
            try
            {
                int _type = REF;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:141:5: ( ( 'A' .. 'Z' )+ ( '0' .. '9' )+ )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:141:7: ( 'A' .. 'Z' )+ ( '0' .. '9' )+
                {
                    DebugLocation(141, 7);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:141:7: ( 'A' .. 'Z' )+
                    int cnt6 = 0;
                    try
                    {
                        DebugEnterSubRule(6);
                        while (true)
                        {
                            int alt6 = 2;
                            try
                            {
                                DebugEnterDecision(6, decisionCanBacktrack[6]);
                                int LA6_0 = input.LA(1);

                                if (((LA6_0 >= 'A' && LA6_0 <= 'Z')))
                                {
                                    alt6 = 1;
                                }


                            }
                            finally { DebugExitDecision(6); }
                            switch (alt6)
                            {
                                case 1:
                                    DebugEnterAlt(1);
                                    // C:\\projects\\Expressions\\antlr\\Expression.g:141:8: 'A' .. 'Z'
                                    {
                                        DebugLocation(141, 8);
                                        MatchRange('A', 'Z');

                                    }
                                    break;

                                default:
                                    if (cnt6 >= 1)
                                        goto loop6;

                                    EarlyExitException eee6 = new EarlyExitException(6, input);
                                    DebugRecognitionException(eee6);
                                    throw eee6;
                            }
                            cnt6++;
                        }
                        loop6:
                        ;

                    }
                    finally { DebugExitSubRule(6); }

                    DebugLocation(141, 19);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:141:19: ( '0' .. '9' )+
                    int cnt7 = 0;
                    try
                    {
                        DebugEnterSubRule(7);
                        while (true)
                        {
                            int alt7 = 2;
                            try
                            {
                                DebugEnterDecision(7, decisionCanBacktrack[7]);
                                int LA7_0 = input.LA(1);

                                if (((LA7_0 >= '0' && LA7_0 <= '9')))
                                {
                                    alt7 = 1;
                                }


                            }
                            finally { DebugExitDecision(7); }
                            switch (alt7)
                            {
                                case 1:
                                    DebugEnterAlt(1);
                                    // C:\\projects\\Expressions\\antlr\\Expression.g:141:20: '0' .. '9'
                                    {
                                        DebugLocation(141, 20);
                                        MatchRange('0', '9');

                                    }
                                    break;

                                default:
                                    if (cnt7 >= 1)
                                        goto loop7;

                                    EarlyExitException eee7 = new EarlyExitException(7, input);
                                    DebugRecognitionException(eee7);
                                    throw eee7;
                            }
                            cnt7++;
                        }
                        loop7:
                        ;

                    }
                    finally { DebugExitSubRule(7); }


                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("REF", 20);
                LeaveRule("REF", 20);
                Leave_REF();
            }
        }
        // $ANTLR end "REF"

        partial void Enter_REFRANGE();
        partial void Leave_REFRANGE();

        // $ANTLR start "REFRANGE"
        [GrammarRule("REFRANGE")]
        private void mREFRANGE()
        {
            Enter_REFRANGE();
            EnterRule("REFRANGE", 21);
            TraceIn("REFRANGE", 21);
            try
            {
                int _type = REFRANGE;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:144:2: ( ( REF ':' REF ) )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:144:4: ( REF ':' REF )
                {
                    DebugLocation(144, 4);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:144:4: ( REF ':' REF )
                    DebugEnterAlt(1);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:144:5: REF ':' REF
                    {
                        DebugLocation(144, 5);
                        mREF();
                        DebugLocation(144, 9);
                        Match(':');
                        DebugLocation(144, 13);
                        mREF();

                    }


                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("REFRANGE", 21);
                LeaveRule("REFRANGE", 21);
                Leave_REFRANGE();
            }
        }
        // $ANTLR end "REFRANGE"

        partial void Enter_STRING();
        partial void Leave_STRING();

        // $ANTLR start "STRING"
        [GrammarRule("STRING")]
        private void mSTRING()
        {
            Enter_STRING();
            EnterRule("STRING", 22);
            TraceIn("STRING", 22);
            try
            {
                int _type = STRING;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:148:6: ( '\\'' ( EscapeSequence | ( options {greedy=false; } : ~ ( '\\u0000' .. '\\u001f' | '\\\\' | '\\'' ) ) )* '\\'' )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:148:10: '\\'' ( EscapeSequence | ( options {greedy=false; } : ~ ( '\\u0000' .. '\\u001f' | '\\\\' | '\\'' ) ) )* '\\''
                {
                    DebugLocation(148, 10);
                    Match('\'');
                    DebugLocation(148, 15);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:148:15: ( EscapeSequence | ( options {greedy=false; } : ~ ( '\\u0000' .. '\\u001f' | '\\\\' | '\\'' ) ) )*
                    try
                    {
                        DebugEnterSubRule(8);
                        while (true)
                        {
                            int alt8 = 3;
                            try
                            {
                                DebugEnterDecision(8, decisionCanBacktrack[8]);
                                int LA8_0 = input.LA(1);

                                if ((LA8_0 == '\\'))
                                {
                                    alt8 = 1;
                                }
                                else if (((LA8_0 >= ' ' && LA8_0 <= '&') || (LA8_0 >= '(' && LA8_0 <= '[') || (LA8_0 >= ']' && LA8_0 <= '\uFFFF')))
                                {
                                    alt8 = 2;
                                }


                            }
                            finally { DebugExitDecision(8); }
                            switch (alt8)
                            {
                                case 1:
                                    DebugEnterAlt(1);
                                    // C:\\projects\\Expressions\\antlr\\Expression.g:148:17: EscapeSequence
                                    {
                                        DebugLocation(148, 17);
                                        mEscapeSequence();

                                    }
                                    break;
                                case 2:
                                    DebugEnterAlt(2);
                                    // C:\\projects\\Expressions\\antlr\\Expression.g:148:34: ( options {greedy=false; } : ~ ( '\\u0000' .. '\\u001f' | '\\\\' | '\\'' ) )
                                    {
                                        DebugLocation(148, 34);
                                        // C:\\projects\\Expressions\\antlr\\Expression.g:148:34: ( options {greedy=false; } : ~ ( '\\u0000' .. '\\u001f' | '\\\\' | '\\'' ) )
                                        DebugEnterAlt(1);
                                        // C:\\projects\\Expressions\\antlr\\Expression.g:148:61: ~ ( '\\u0000' .. '\\u001f' | '\\\\' | '\\'' )
                                        {
                                            DebugLocation(148, 61);
                                            if ((input.LA(1) >= ' ' && input.LA(1) <= '&') || (input.LA(1) >= '(' && input.LA(1) <= '[') || (input.LA(1) >= ']' && input.LA(1) <= '\uFFFF'))
                                            {
                                                input.Consume();

                                            }
                                            else
                                            {
                                                MismatchedSetException mse = new MismatchedSetException(null, input);
                                                DebugRecognitionException(mse);
                                                Recover(mse);
                                                throw mse;
                                            }


                                        }


                                    }
                                    break;

                                default:
                                    goto loop8;
                            }
                        }

                        loop8:
                        ;

                    }
                    finally { DebugExitSubRule(8); }

                    DebugLocation(148, 103);
                    Match('\'');

                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("STRING", 22);
                LeaveRule("STRING", 22);
                Leave_STRING();
            }
        }
        // $ANTLR end "STRING"

        partial void Enter_INTEGER();
        partial void Leave_INTEGER();

        // $ANTLR start "INTEGER"
        [GrammarRule("INTEGER")]
        private void mINTEGER()
        {
            Enter_INTEGER();
            EnterRule("INTEGER", 23);
            TraceIn("INTEGER", 23);
            try
            {
                int _type = INTEGER;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:152:2: ( ( '0' .. '9' )+ )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:152:4: ( '0' .. '9' )+
                {
                    DebugLocation(152, 4);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:152:4: ( '0' .. '9' )+
                    int cnt9 = 0;
                    try
                    {
                        DebugEnterSubRule(9);
                        while (true)
                        {
                            int alt9 = 2;
                            try
                            {
                                DebugEnterDecision(9, decisionCanBacktrack[9]);
                                int LA9_0 = input.LA(1);

                                if (((LA9_0 >= '0' && LA9_0 <= '9')))
                                {
                                    alt9 = 1;
                                }


                            }
                            finally { DebugExitDecision(9); }
                            switch (alt9)
                            {
                                case 1:
                                    DebugEnterAlt(1);
                                    // C:\\projects\\Expressions\\antlr\\Expression.g:152:5: '0' .. '9'
                                    {
                                        DebugLocation(152, 5);
                                        MatchRange('0', '9');

                                    }
                                    break;

                                default:
                                    if (cnt9 >= 1)
                                        goto loop9;

                                    EarlyExitException eee9 = new EarlyExitException(9, input);
                                    DebugRecognitionException(eee9);
                                    throw eee9;
                            }
                            cnt9++;
                        }
                        loop9:
                        ;

                    }
                    finally { DebugExitSubRule(9); }


                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("INTEGER", 23);
                LeaveRule("INTEGER", 23);
                Leave_INTEGER();
            }
        }
        // $ANTLR end "INTEGER"

        partial void Enter_FLOAT();
        partial void Leave_FLOAT();

        // $ANTLR start "FLOAT"
        [GrammarRule("FLOAT")]
        private void mFLOAT()
        {
            Enter_FLOAT();
            EnterRule("FLOAT", 24);
            TraceIn("FLOAT", 24);
            try
            {
                int _type = FLOAT;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:156:2: ( ( '0' .. '9' )* '.' ( '0' .. '9' )+ )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:156:4: ( '0' .. '9' )* '.' ( '0' .. '9' )+
                {
                    DebugLocation(156, 4);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:156:4: ( '0' .. '9' )*
                    try
                    {
                        DebugEnterSubRule(10);
                        while (true)
                        {
                            int alt10 = 2;
                            try
                            {
                                DebugEnterDecision(10, decisionCanBacktrack[10]);
                                int LA10_0 = input.LA(1);

                                if (((LA10_0 >= '0' && LA10_0 <= '9')))
                                {
                                    alt10 = 1;
                                }


                            }
                            finally { DebugExitDecision(10); }
                            switch (alt10)
                            {
                                case 1:
                                    DebugEnterAlt(1);
                                    // C:\\projects\\Expressions\\antlr\\Expression.g:156:5: '0' .. '9'
                                    {
                                        DebugLocation(156, 5);
                                        MatchRange('0', '9');

                                    }
                                    break;

                                default:
                                    goto loop10;
                            }
                        }

                        loop10:
                        ;

                    }
                    finally { DebugExitSubRule(10); }

                    DebugLocation(156, 16);
                    Match('.');
                    DebugLocation(156, 20);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:156:20: ( '0' .. '9' )+
                    int cnt11 = 0;
                    try
                    {
                        DebugEnterSubRule(11);
                        while (true)
                        {
                            int alt11 = 2;
                            try
                            {
                                DebugEnterDecision(11, decisionCanBacktrack[11]);
                                int LA11_0 = input.LA(1);

                                if (((LA11_0 >= '0' && LA11_0 <= '9')))
                                {
                                    alt11 = 1;
                                }


                            }
                            finally { DebugExitDecision(11); }
                            switch (alt11)
                            {
                                case 1:
                                    DebugEnterAlt(1);
                                    // C:\\projects\\Expressions\\antlr\\Expression.g:156:21: '0' .. '9'
                                    {
                                        DebugLocation(156, 21);
                                        MatchRange('0', '9');

                                    }
                                    break;

                                default:
                                    if (cnt11 >= 1)
                                        goto loop11;

                                    EarlyExitException eee11 = new EarlyExitException(11, input);
                                    DebugRecognitionException(eee11);
                                    throw eee11;
                            }
                            cnt11++;
                        }
                        loop11:
                        ;

                    }
                    finally { DebugExitSubRule(11); }


                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("FLOAT", 24);
                LeaveRule("FLOAT", 24);
                Leave_FLOAT();
            }
        }
        // $ANTLR end "FLOAT"

        partial void Enter_IDENT();
        partial void Leave_IDENT();

        // $ANTLR start "IDENT"
        [GrammarRule("IDENT")]
        private void mIDENT()
        {
            Enter_IDENT();
            EnterRule("IDENT", 25);
            TraceIn("IDENT", 25);
            try
            {
                int _type = FUNCTION;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:170:2: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:170:4: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
                {
                    DebugLocation(170, 4);
                    if ((input.LA(1) >= 'A' && input.LA(1) <= 'Z') || input.LA(1) == '_' || (input.LA(1) >= 'a' && input.LA(1) <= 'z'))
                    {
                        input.Consume();

                    }
                    else
                    {
                        MismatchedSetException mse = new MismatchedSetException(null, input);
                        DebugRecognitionException(mse);
                        Recover(mse);
                        throw mse;
                    }

                    DebugLocation(170, 33);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:170:33: ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )*
                    try
                    {
                        DebugEnterSubRule(12);
                        while (true)
                        {
                            int alt12 = 2;
                            try
                            {
                                DebugEnterDecision(12, decisionCanBacktrack[12]);
                                int LA12_0 = input.LA(1);

                                if (((LA12_0 >= '0' && LA12_0 <= '9') || (LA12_0 >= 'A' && LA12_0 <= 'Z') || LA12_0 == '_' || (LA12_0 >= 'a' && LA12_0 <= 'z')))
                                {
                                    alt12 = 1;
                                }


                            }
                            finally { DebugExitDecision(12); }
                            switch (alt12)
                            {
                                case 1:
                                    DebugEnterAlt(1);
                                    // C:\\projects\\Expressions\\antlr\\Expression.g:
                                    {
                                        DebugLocation(170, 33);
                                        if ((input.LA(1) >= '0' && input.LA(1) <= '9') || (input.LA(1) >= 'A' && input.LA(1) <= 'Z') || input.LA(1) == '_' || (input.LA(1) >= 'a' && input.LA(1) <= 'z'))
                                        {
                                            input.Consume();

                                        }
                                        else
                                        {
                                            MismatchedSetException mse = new MismatchedSetException(null, input);
                                            DebugRecognitionException(mse);
                                            Recover(mse);
                                            throw mse;
                                        }


                                    }
                                    break;

                                default:
                                    goto loop12;
                            }
                        }

                        loop12:
                        ;

                    }
                    finally { DebugExitSubRule(12); }


                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("IDENT", 25);
                LeaveRule("IDENT", 25);
                Leave_IDENT();
            }
        }
        // $ANTLR end "IDENT"

        partial void Enter_EscapeSequence();
        partial void Leave_EscapeSequence();

        // $ANTLR start "EscapeSequence"
        [GrammarRule("EscapeSequence")]
        private void mEscapeSequence()
        {
            Enter_EscapeSequence();
            EnterRule("EscapeSequence", 26);
            TraceIn("EscapeSequence", 26);
            try
            {
                // C:\\projects\\Expressions\\antlr\\Expression.g:174:2: ( '\\\\' ( 'n' | 'r' | 't' | '\\'' | '\\\\' | UnicodeEscape ) )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:174:4: '\\\\' ( 'n' | 'r' | 't' | '\\'' | '\\\\' | UnicodeEscape )
                {
                    DebugLocation(174, 4);
                    Match('\\');
                    DebugLocation(175, 4);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:175:4: ( 'n' | 'r' | 't' | '\\'' | '\\\\' | UnicodeEscape )
                    int alt13 = 6;
                    try
                    {
                        DebugEnterSubRule(13);
                        try
                        {
                            DebugEnterDecision(13, decisionCanBacktrack[13]);
                            switch (input.LA(1))
                            {
                                case 'n':
                                    {
                                        alt13 = 1;
                                    }
                                    break;
                                case 'r':
                                    {
                                        alt13 = 2;
                                    }
                                    break;
                                case 't':
                                    {
                                        alt13 = 3;
                                    }
                                    break;
                                case '\'':
                                    {
                                        alt13 = 4;
                                    }
                                    break;
                                case '\\':
                                    {
                                        alt13 = 5;
                                    }
                                    break;
                                case 'u':
                                    {
                                        alt13 = 6;
                                    }
                                    break;
                                default:
                                    {
                                        NoViableAltException nvae = new NoViableAltException("", 13, 0, input);

                                        DebugRecognitionException(nvae);
                                        throw nvae;
                                    }
                            }

                        }
                        finally { DebugExitDecision(13); }
                        switch (alt13)
                        {
                            case 1:
                                DebugEnterAlt(1);
                                // C:\\projects\\Expressions\\antlr\\Expression.g:176:5: 'n'
                                {
                                    DebugLocation(176, 5);
                                    Match('n');

                                }
                                break;
                            case 2:
                                DebugEnterAlt(2);
                                // C:\\projects\\Expressions\\antlr\\Expression.g:177:4: 'r'
                                {
                                    DebugLocation(177, 4);
                                    Match('r');

                                }
                                break;
                            case 3:
                                DebugEnterAlt(3);
                                // C:\\projects\\Expressions\\antlr\\Expression.g:178:4: 't'
                                {
                                    DebugLocation(178, 4);
                                    Match('t');

                                }
                                break;
                            case 4:
                                DebugEnterAlt(4);
                                // C:\\projects\\Expressions\\antlr\\Expression.g:179:4: '\\''
                                {
                                    DebugLocation(179, 4);
                                    Match('\'');

                                }
                                break;
                            case 5:
                                DebugEnterAlt(5);
                                // C:\\projects\\Expressions\\antlr\\Expression.g:180:4: '\\\\'
                                {
                                    DebugLocation(180, 4);
                                    Match('\\');

                                }
                                break;
                            case 6:
                                DebugEnterAlt(6);
                                // C:\\projects\\Expressions\\antlr\\Expression.g:181:4: UnicodeEscape
                                {
                                    DebugLocation(181, 4);
                                    mUnicodeEscape();

                                }
                                break;

                        }
                    }
                    finally { DebugExitSubRule(13); }


                }

            }
            finally
            {
                TraceOut("EscapeSequence", 26);
                LeaveRule("EscapeSequence", 26);
                Leave_EscapeSequence();
            }
        }
        // $ANTLR end "EscapeSequence"

        partial void Enter_UnicodeEscape();
        partial void Leave_UnicodeEscape();

        // $ANTLR start "UnicodeEscape"
        [GrammarRule("UnicodeEscape")]
        private void mUnicodeEscape()
        {
            Enter_UnicodeEscape();
            EnterRule("UnicodeEscape", 27);
            TraceIn("UnicodeEscape", 27);
            try
            {
                // C:\\projects\\Expressions\\antlr\\Expression.g:186:6: ( 'u' HexDigit HexDigit HexDigit HexDigit )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:186:12: 'u' HexDigit HexDigit HexDigit HexDigit
                {
                    DebugLocation(186, 12);
                    Match('u');
                    DebugLocation(186, 16);
                    mHexDigit();
                    DebugLocation(186, 25);
                    mHexDigit();
                    DebugLocation(186, 34);
                    mHexDigit();
                    DebugLocation(186, 43);
                    mHexDigit();

                }

            }
            finally
            {
                TraceOut("UnicodeEscape", 27);
                LeaveRule("UnicodeEscape", 27);
                Leave_UnicodeEscape();
            }
        }
        // $ANTLR end "UnicodeEscape"

        partial void Enter_HexDigit();
        partial void Leave_HexDigit();

        // $ANTLR start "HexDigit"
        [GrammarRule("HexDigit")]
        private void mHexDigit()
        {
            Enter_HexDigit();
            EnterRule("HexDigit", 28);
            TraceIn("HexDigit", 28);
            try
            {
                // C:\\projects\\Expressions\\antlr\\Expression.g:190:2: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:190:5: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )
                {
                    DebugLocation(190, 5);
                    if ((input.LA(1) >= '0' && input.LA(1) <= '9') || (input.LA(1) >= 'A' && input.LA(1) <= 'F') || (input.LA(1) >= 'a' && input.LA(1) <= 'f'))
                    {
                        input.Consume();

                    }
                    else
                    {
                        MismatchedSetException mse = new MismatchedSetException(null, input);
                        DebugRecognitionException(mse);
                        Recover(mse);
                        throw mse;
                    }


                }

            }
            finally
            {
                TraceOut("HexDigit", 28);
                LeaveRule("HexDigit", 28);
                Leave_HexDigit();
            }
        }
        // $ANTLR end "HexDigit"

        partial void Enter_WS();
        partial void Leave_WS();

        // $ANTLR start "WS"
        [GrammarRule("WS")]
        private void mWS()
        {
            Enter_WS();
            EnterRule("WS", 29);
            TraceIn("WS", 29);
            try
            {
                int _type = WS;
                int _channel = DefaultTokenChannel;
                // C:\\projects\\Expressions\\antlr\\Expression.g:193:2: ( ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' ) )
                DebugEnterAlt(1);
                // C:\\projects\\Expressions\\antlr\\Expression.g:193:5: ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' )
                {
                    DebugLocation(193, 5);
                    if ((input.LA(1) >= '\t' && input.LA(1) <= '\n') || (input.LA(1) >= '\f' && input.LA(1) <= '\r') || input.LA(1) == ' ')
                    {
                        input.Consume();

                    }
                    else
                    {
                        MismatchedSetException mse = new MismatchedSetException(null, input);
                        DebugRecognitionException(mse);
                        Recover(mse);
                        throw mse;
                    }

                    DebugLocation(193, 35);
                    _channel = Hidden;

                }

                state.type = _type;
                state.channel = _channel;
            }
            finally
            {
                TraceOut("WS", 29);
                LeaveRule("WS", 29);
                Leave_WS();
            }
        }
        // $ANTLR end "WS"

        public override void mTokens()
        {
            // C:\\projects\\Expressions\\antlr\\Expression.g:1:8: ( T__34 | T__35 | T__36 | OR | AND | EQUALS | NOTEQUALS | LT | LTEQ | GT | GTEQ | PLUS | MINUS | MULT | DIV | MOD | POW | NOT | PAR | REF | REFRANGE | STRING | INTEGER | FLOAT | IDENT | WS )
            int alt14 = 26;
            try
            {
                DebugEnterDecision(14, decisionCanBacktrack[14]);
                try
                {
                    alt14 = dfa14.Predict(input);
                }
                catch (NoViableAltException nvae)
                {
                    DebugRecognitionException(nvae);
                    throw;
                }
            }
            finally { DebugExitDecision(14); }
            switch (alt14)
            {
                case 1:
                    DebugEnterAlt(1);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:10: T__34
                    {
                        DebugLocation(1, 10);
                        mT__34();

                    }
                    break;
                case 2:
                    DebugEnterAlt(2);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:16: T__35
                    {
                        DebugLocation(1, 16);
                        mT__35();

                    }
                    break;
                case 3:
                    DebugEnterAlt(3);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:22: T__36
                    {
                        DebugLocation(1, 22);
                        mT__36();

                    }
                    break;
                case 4:
                    DebugEnterAlt(4);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:28: OR
                    {
                        DebugLocation(1, 28);
                        mOR();

                    }
                    break;
                case 5:
                    DebugEnterAlt(5);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:31: AND
                    {
                        DebugLocation(1, 31);
                        mAND();

                    }
                    break;
                case 6:
                    DebugEnterAlt(6);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:35: EQUALS
                    {
                        DebugLocation(1, 35);
                        mEQUALS();

                    }
                    break;
                case 7:
                    DebugEnterAlt(7);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:42: NOTEQUALS
                    {
                        DebugLocation(1, 42);
                        mNOTEQUALS();

                    }
                    break;
                case 8:
                    DebugEnterAlt(8);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:52: LT
                    {
                        DebugLocation(1, 52);
                        mLT();

                    }
                    break;
                case 9:
                    DebugEnterAlt(9);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:55: LTEQ
                    {
                        DebugLocation(1, 55);
                        mLTEQ();

                    }
                    break;
                case 10:
                    DebugEnterAlt(10);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:60: GT
                    {
                        DebugLocation(1, 60);
                        mGT();

                    }
                    break;
                case 11:
                    DebugEnterAlt(11);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:63: GTEQ
                    {
                        DebugLocation(1, 63);
                        mGTEQ();

                    }
                    break;
                case 12:
                    DebugEnterAlt(12);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:68: PLUS
                    {
                        DebugLocation(1, 68);
                        mPLUS();

                    }
                    break;
                case 13:
                    DebugEnterAlt(13);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:73: MINUS
                    {
                        DebugLocation(1, 73);
                        mMINUS();

                    }
                    break;
                case 14:
                    DebugEnterAlt(14);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:79: MULT
                    {
                        DebugLocation(1, 79);
                        mMULT();

                    }
                    break;
                case 15:
                    DebugEnterAlt(15);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:84: DIV
                    {
                        DebugLocation(1, 84);
                        mDIV();

                    }
                    break;
                case 16:
                    DebugEnterAlt(16);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:88: MOD
                    {
                        DebugLocation(1, 88);
                        mMOD();

                    }
                    break;
                case 17:
                    DebugEnterAlt(17);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:92: POW
                    {
                        DebugLocation(1, 92);
                        mPOW();

                    }
                    break;
                case 18:
                    DebugEnterAlt(18);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:96: NOT
                    {
                        DebugLocation(1, 96);
                        mNOT();

                    }
                    break;
                case 19:
                    DebugEnterAlt(19);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:100: PAR
                    {
                        DebugLocation(1, 100);
                        mPAR();

                    }
                    break;
                case 20:
                    DebugEnterAlt(20);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:104: REF
                    {
                        DebugLocation(1, 104);
                        mREF();

                    }
                    break;
                case 21:
                    DebugEnterAlt(21);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:108: REFRANGE
                    {
                        DebugLocation(1, 108);
                        mREFRANGE();

                    }
                    break;
                case 22:
                    DebugEnterAlt(22);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:117: STRING
                    {
                        DebugLocation(1, 117);
                        mSTRING();

                    }
                    break;
                case 23:
                    DebugEnterAlt(23);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:124: INTEGER
                    {
                        DebugLocation(1, 124);
                        mINTEGER();

                    }
                    break;
                case 24:
                    DebugEnterAlt(24);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:132: FLOAT
                    {
                        DebugLocation(1, 132);
                        mFLOAT();

                    }
                    break;
                case 25:
                    DebugEnterAlt(25);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:138: IDENT
                    {
                        DebugLocation(1, 138);
                        mIDENT();

                    }
                    break;
                case 26:
                    DebugEnterAlt(26);
                    // C:\\projects\\Expressions\\antlr\\Expression.g:1:144: WS
                    {
                        DebugLocation(1, 144);
                        mWS();

                    }
                    break;

            }

        }


        #region DFA
        DFA14 dfa14;

        protected override void InitDFAs()
        {
            base.InitDFAs();
            dfa14 = new DFA14(this);
        }

        private class DFA14 : DFA
        {
            private const string DFA14_eotS =
                "\x5\xFFFF\x1\x18\x1\xFFFF\x1\x18\x1\xFFFF\x1\x1D\x1\x1F\x1\x21\x6\xFFFF" +
                "\x1\x18\x1\x23\x1\x18\x1\xFFFF\x1\x26\x3\xFFFF\x1\x4\x1\x18\x6\xFFFF" +
                "\x1\x18\x1\xFFFF\x1\x29\x1\x18\x1\xFFFF\x1\x6\x1\x1D\x2\xFFFF";
            private const string DFA14_eofS =
                "\x2B\xFFFF";
            private const string DFA14_minS =
                "\x1\x9\x4\xFFFF\x1\x72\x1\xFFFF\x1\x6E\x1\xFFFF\x3\x3D\x6\xFFFF\x1\x6F" +
                "\x2\x30\x1\xFFFF\x1\x2E\x3\xFFFF\x1\x30\x1\x64\x6\xFFFF\x1\x74\x1\xFFFF" +
                "\x2\x30\x1\xFFFF\x2\x30\x2\xFFFF";
            private const string DFA14_maxS =
                "\x1\x7C\x4\xFFFF\x1\x72\x1\xFFFF\x1\x6E\x1\xFFFF\x1\x3D\x1\x3E\x1\x3D" +
                "\x6\xFFFF\x1\x6F\x1\x7A\x1\x5A\x1\xFFFF\x1\x39\x3\xFFFF\x1\x7A\x1\x64" +
                "\x6\xFFFF\x1\x74\x1\xFFFF\x1\x7A\x1\x5A\x1\xFFFF\x2\x7A\x2\xFFFF";
            private const string DFA14_acceptS =
                "\x1\xFFFF\x1\x1\x1\x2\x1\x3\x1\x4\x1\xFFFF\x1\x5\x1\xFFFF\x1\x6\x3\xFFFF" +
                "\x1\xC\x1\xD\x1\xE\x1\xF\x1\x10\x1\x11\x3\xFFFF\x1\x16\x1\xFFFF\x1\x18" +
                "\x1\x19\x1\x1A\x2\xFFFF\x1\x7\x1\x12\x1\x9\x1\x8\x1\xB\x1\xA\x1\xFFFF" +
                "\x1\x13\x2\xFFFF\x1\x17\x2\xFFFF\x1\x14\x1\x15";
            private const string DFA14_specialS =
                "\x2B\xFFFF}>";
            private static readonly string[] DFA14_transitionS =
                {
                    "\x2\x19\x1\xFFFF\x2\x19\x12\xFFFF\x1\x19\x1\x9\x3\xFFFF\x1\x10\x1\x6"+
                    "\x1\x15\x1\x1\x1\x2\x1\xE\x1\xC\x1\x3\x1\xD\x1\x17\x1\xF\xA\x16\x2\xFFFF"+
                    "\x1\xA\x1\x8\x1\xB\x2\xFFFF\x17\x14\x2\x13\x1\x14\x3\xFFFF\x1\x11\x1"+
                    "\x18\x1\xFFFF\x1\x7\xC\x18\x1\x12\x1\x5\xB\x18\x1\xFFFF\x1\x4",
                    "",
                    "",
                    "",
                    "",
                    "\x1\x1A",
                    "",
                    "\x1\x1B",
                    "",
                    "\x1\x1C",
                    "\x1\x1E\x1\x1C",
                    "\x1\x20",
                    "",
                    "",
                    "",
                    "",
                    "",
                    "",
                    "\x1\x22",
                    "\xA\x24\x7\xFFFF\x1A\x25\x4\xFFFF\x1\x18\x1\xFFFF\x1A\x18",
                    "\xA\x24\x7\xFFFF\x1A\x25",
                    "",
                    "\x1\x17\x1\xFFFF\xA\x16",
                    "",
                    "",
                    "",
                    "\xA\x18\x7\xFFFF\x1A\x18\x4\xFFFF\x1\x18\x1\xFFFF\x1A\x18",
                    "\x1\x27",
                    "",
                    "",
                    "",
                    "",
                    "",
                    "",
                    "\x1\x28",
                    "",
                    "\xA\x24\x1\x2A\x6\xFFFF\x1A\x18\x4\xFFFF\x1\x18\x1\xFFFF\x1A\x18",
                    "\xA\x24\x7\xFFFF\x1A\x25",
                    "",
                    "\xA\x18\x7\xFFFF\x1A\x18\x4\xFFFF\x1\x18\x1\xFFFF\x1A\x18",
                    "\xA\x18\x7\xFFFF\x1A\x18\x4\xFFFF\x1\x18\x1\xFFFF\x1A\x18",
                    "",
                    ""
                };

            private static readonly short[] DFA14_eot = DFA.UnpackEncodedString(DFA14_eotS);
            private static readonly short[] DFA14_eof = DFA.UnpackEncodedString(DFA14_eofS);
            private static readonly char[] DFA14_min = DFA.UnpackEncodedStringToUnsignedChars(DFA14_minS);
            private static readonly char[] DFA14_max = DFA.UnpackEncodedStringToUnsignedChars(DFA14_maxS);
            private static readonly short[] DFA14_accept = DFA.UnpackEncodedString(DFA14_acceptS);
            private static readonly short[] DFA14_special = DFA.UnpackEncodedString(DFA14_specialS);
            private static readonly short[][] DFA14_transition;

            static DFA14()
            {
                int numStates = DFA14_transitionS.Length;
                DFA14_transition = new short[numStates][];
                for (int i = 0; i < numStates; i++)
                {
                    DFA14_transition[i] = DFA.UnpackEncodedString(DFA14_transitionS[i]);
                }
            }

            public DFA14(BaseRecognizer recognizer)
            {
                this.recognizer = recognizer;
                this.decisionNumber = 14;
                this.eot = DFA14_eot;
                this.eof = DFA14_eof;
                this.min = DFA14_min;
                this.max = DFA14_max;
                this.accept = DFA14_accept;
                this.special = DFA14_special;
                this.transition = DFA14_transition;
            }

            public override string Description { get { return "1:1: Tokens : ( T__34 | T__35 | T__36 | OR | AND | EQUALS | NOTEQUALS | LT | LTEQ | GT | GTEQ | PLUS | MINUS | MULT | DIV | MOD | POW | NOT | PAR | REF | REFRANGE | STRING | INTEGER | FLOAT | IDENT | WS );"; } }

            public override void Error(NoViableAltException nvae)
            {
                DebugRecognitionException(nvae);
            }
        }


        #endregion

    }
}
